.TH std::jthread 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::jthread \- std::jthread

.SH Synopsis
   Defined in header <thread>
   class jthread;              \fI(since C++20)\fP

   The class jthread represents a single thread of execution. It has the same general
   behavior as std::thread, except that jthread automatically rejoins on destruction,
   and can be cancelled/stopped in certain situations.

   Threads begin execution immediately upon construction of the associated thread
   object (pending any OS scheduling delays), starting at the top-level function
   provided as a constructor argument. The return value of the top-level function is
   ignored and if it terminates by throwing an exception, std::terminate is called. The
   top-level function may communicate its return value or an exception to the caller
   via std::promise or by modifying shared variables (which may require
   synchronization, see std::mutex and std::atomic).

   Unlike std::thread, the jthread logically holds an internal private member of type
   std::stop_source, which maintains a shared stop-state. The jthread constructor
   accepts a function that takes a std::stop_token as its first argument, which will be
   passed in by the jthread from its internal std::stop_source. This allows the
   function to check if stop has been requested during its execution, and return if it
   has.

   std::jthread objects may also be in the state that does not represent any thread
   (after default construction, move from, detach, or join), and a thread of execution
   may be not associated with any jthread objects (after detach).

   No two std::jthread objects may represent the same thread of execution; std::jthread
   is not CopyConstructible or CopyAssignable, although it is MoveConstructible and
   MoveAssignable.

.SH Member types

   Member type                    Definition
   id                             std::thread::id
   native_handle_type (optional*) std::thread::native_handle_type

.SH Member functions

   constructor          constructs new jthread object
                        \fI(public member function)\fP
                        if the thread is joinable, then a stop is requested and the
   destructor           thread joins
                        \fI(public member function)\fP
   operator=            moves the jthread object
                        \fI(public member function)\fP
.SH Observers
                        checks whether the thread is joinable, i.e. potentially running
   joinable             in parallel context
                        \fI(public member function)\fP
   get_id               returns the id of the thread
                        \fI(public member function)\fP
   native_handle        returns the underlying implementation-defined thread handle
                        \fI(public member function)\fP
   hardware_concurrency returns the number of concurrent threads supported by the
   \fB[static]\fP             implementation
                        \fI(public static member function)\fP
.SH Operations
   join                 waits for the thread to finish its execution
                        \fI(public member function)\fP
                        permits the thread to execute independently from the thread
   detach               handle
                        \fI(public member function)\fP
   swap                 swaps two jthread objects
                        \fI(public member function)\fP
         Stop token handling
                        returns a stop_source object associated with the shared stop
   get_stop_source      state of the thread
                        \fI(public member function)\fP
                        returns a stop_token associated with the shared stop state of
   get_stop_token       the thread
                        \fI(public member function)\fP
   request_stop         requests execution stop via the shared stop state of the thread
                        \fI(public member function)\fP

.SH Non-member functions

   swap(std::jthread) specializes the std::swap algorithm
   (C++20)            \fI(function)\fP

.SH Notes

   Feature-test macro  Value    Std              Feature
   __cpp_lib_jthread  201911L (C++20) Stop token and joining thread

.SH See also

   thread  manages a separate thread
   \fI(C++11)\fP \fI(class)\fP
